//给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。 
//
// 示例 1: 
//
// 
//输入: "abab"
//
//输出: True
//
//解释: 可由子字符串 "ab" 重复两次构成。
// 
//
// 示例 2: 
//
// 
//输入: "aba"
//
//输出: False
// 
//
// 示例 3: 
//
// 
//输入: "abcabcabcabc"
//
//输出: True
//
//解释: 可由子字符串 "abc" 重复四次构成。 (或者子字符串 "abcabc" 重复两次构成。)
// 
// Related Topics 字符串 字符串匹配 
// 👍 584 👎 0

package com.cute.leetcode.editor.cn;
public class RepeatedSubstringPattern {
    public static void main(String[] args) {
        new RepeatedSubstringPattern().new Solution().repeatedSubstringPattern("abba");
    }
    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
        /**
         * 这个方法比较直观，便于理解：
         * 1.从头开始找出所有子串
         * 2.按照子串长度遍历所有位置进行匹配
         * 3.只要没匹配上就放弃当前子串
         *
         * 几处优化的地方：
         * 1.子串的最大长度为 s.len/2 甚至可以根据奇偶进行跳跃操作
         * 2.目标串长度%子串长度必须为0
         * 这种时间居中
         */
        public boolean repeatedSubstringPattern1(String s) {
            int len = s.length();
            if (len == 1) return false;
            for (int i = 0; i < len/2; i++) {
                String substring = s.substring(0, i + 1);//获取子串
                int subLen = substring.length();
                if (len%subLen != 0) continue;//不满足条件就跳过
                for (int j = i+1; j < len; j+=subLen) {
                    if (!substring.equals(s.substring(j, j+subLen))) break;//匹配不上就放弃当前子串
                    if (j+subLen == len) return true;
                }
            }
            return false;
        }

        /**
         * 使用KMP算法求前缀表，根据前缀表进行判断
         * 前缀表就是最普通的前缀表，没有移动或者减1
         * 假设len是字符串的长度，那么如果next[len-1]!=0，即说明字符串有相同的前后缀
         * 且最长相等前后缀的长度即为next[len-1]
         * 如果 len % (len - next[len-1]) == 0 则说明存在循环子串
         * 因为len - next[len-1] 即为第一个周期的长度，如果len%周期长度 == 0 说明可以循环构成
         * 这种时间是最快的
         */
        public boolean repeatedSubstringPattern(String s) {
            int[] next = getNext(s);
            int len = s.length();
            return next[len - 1] != 0 && len % (len - next[len - 1]) == 0;
        }

        public int[] getNext(String s){
            int len = s.length();
            char[] chars = s.toCharArray();
            int[] next = new int[len];
            next[0] = 0;
            int j = 0;
            for (int i = 1; i < len; i++) {
                while (j > 0 && chars[i]!=chars[j]) j = next[j-1];
                if (chars[i] == chars[j]) j++;
                next[i] = j;
            }
            return next;
        }

        /**
         * 构造两倍字符串的方法，
         * 如果原字符串中没有循环，那么找起始位置的时候只能找到拼接后的位置，即为原始字符串长度
         * 如果存在循环的话，那么肯定会在拼接位置之前出现
         * 这种时间是最慢的
         */
        public boolean repeatedSubstringPattern3(String s) {
            return (s+s).indexOf(s, 1) != s.length();
        }
    }
//leetcode submit region end(Prohibit modification and deletion)

}




































